home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / lang / PPCsmalltalk.lha / PPCSmallTalk / parser / parse2.c < prev    next >
C/C++ Source or Header  |  1986-10-19  |  12KB  |  606 lines
  1. /*
  2.     Little Smalltalk 
  3.     pass 2 of the parser
  4.  
  5.     timothy a. budd, 10/84
  6.  
  7. */
  8. /*
  9.     The source code for the Little Smalltalk System may be freely
  10.     copied provided that the source of all files is acknowledged
  11.     and that this condition is copied with each file.
  12.  
  13.     The Little Smalltalk System is distributed without responsibility
  14.     for the performance of the program and without any guarantee of
  15.     maintenance.
  16.  
  17.     All questions concerning Little Smalltalk should be addressed to:
  18.  
  19.         Professor Tim Budd
  20.         Department of Computer Science
  21.         The University of Arizona
  22.         Tucson, Arizona
  23.         85721
  24.         USA
  25. */
  26. #include <stdio.h>
  27. #include "env.h"
  28. #include "drive.h"
  29. #include "cmds.h"
  30. #include "parser.h"
  31. #include "y.tab.h"
  32.  
  33. extern int maxcontext;
  34. extern char *filename;
  35. extern FILE *ofd;
  36.  
  37. static int inblock = 0;
  38. static int topstack = 0;
  39. static int maxstack = 0;
  40. #define bumpstk() if (++topstack > maxstack) maxstack = topstack
  41. #define popstk(i) topstack -= i
  42.  
  43. genclass(clinfo, mlist)
  44. struct classstruct *clinfo;
  45. struct methodstruct *mlist;
  46. {    int i;
  47.     struct methodstruct *m, *n;
  48.  
  49.     topstack = 0;
  50.     maxstack = 0;
  51.  
  52.     /* first find out how many methods have been declared */
  53.     /* also check for multiply defined methods */
  54.     for (m = mlist, i = 0; m; i++, m = m->nextmethod)
  55.         for (n = m->nextmethod; n; n = n->nextmethod)
  56.             if (streq((m->pattern)->cmdname ,
  57.                 (n->pattern)->cmdname))
  58.                 yerr("%s multiply defined",
  59.                     (m->pattern)->cmdname);
  60.  
  61.     fprintf(ofd,"temp <- <primitive 110 %d >\n", i);
  62.  
  63.     /* next print out each method */
  64.     for (m = mlist, i = 1; m; i++, m = m->nextmethod) {
  65.         fprintf(ofd,"<primitive 112 temp %d\t\t\" %s \" \\\n", 
  66.             i, (m->pattern)->cmdname);
  67.         topstack = 0;
  68.         genmeth(m);
  69.         }
  70.  
  71.     /* finally print out class definition stuff */
  72.     fprintf(ofd,"<primitive 98 #%s \\\n", clinfo->name);
  73.     fprintf(ofd,"\t<primitive 97 #%s #%s #%s \\\n", 
  74.         clinfo->name, clinfo->super, filename);
  75.     fprintf(ofd,"\t#( ");
  76.     if (instvars) prvars(instvars);
  77.     fprintf(ofd," ) \\\n");
  78.     fprintf(ofd,"\t#( ");
  79.     for (m = mlist; m; m = m->nextmethod)
  80.         fprintf(ofd,"#%s ", (m->pattern)->cmdname);
  81.     fprintf(ofd," ) \\\n");
  82.     fprintf(ofd,"\ttemp %d %d > >\n\n", 1 + maxcontext, 1 + maxstack);
  83. }
  84.  
  85. prvars(v)
  86. struct varstruct *v;
  87. {
  88.     if (v->nextvar)
  89.         prvars(v->nextvar);
  90.     fprintf(ofd," #%s", v->text);
  91. }
  92.  
  93. static int codetop = 0;
  94. static uchar code[1000];
  95.  
  96. static gencode(value)
  97. int value;
  98. {
  99.     if (value >= 256) {
  100.         yerr("code word too big: %d", value);
  101.         value /= 0;
  102.     }
  103.     code[codetop++] = itouc(value);
  104. }
  105.  
  106. static genhighlow(high, low)
  107. int high, low;
  108. {
  109.     if (high < 0 || high > 16)
  110.     yerr("genhighlow error: %d", high);
  111.     if (low < 16) gencode(high * 16 + low);
  112.     else {
  113.         gencode(TWOBIT * 16 + high);
  114.         gencode(low);
  115.     }
  116. }
  117.  
  118. static struct litstruct *literals[100];
  119. int littop = 0;
  120.  
  121. int litcomp(l1, l2)
  122. struct litstruct *l1, *l2;
  123. {
  124.     if (l1->littype != l2->littype) return(0);
  125.     switch(l1->littype) {
  126.     case charlit: if (l1->ll.litchar != l2->ll.litchar) return(0); break;
  127.     case numlit: if (l1->ll.litint != l2->ll.litint) return(0); break;
  128.     case fnumlit: if (l1->ll.litstr != l2->ll.litstr) return(0); break;
  129.     case strlit: if (strcmp(l1->ll.litstr, l2->ll.litstr)) return(0);
  130.         break;
  131.     case symlit: if (strcmp(l1->ll.litsym, l2->ll.litsym)) return(0);
  132.         break;
  133.     default: return(0);
  134.     }
  135.     return(1);
  136. }
  137.  
  138. int genlitix(l)
  139. struct litstruct *l;
  140. {    int i;
  141.  
  142.     for (i = 0; i < littop; i++)
  143.         if (litcomp(l, literals[i]))
  144.             return(i);
  145.     i = littop;
  146.     literals[littop++] = l;
  147.     return(i);
  148. }
  149.  
  150. static printalit(lit)
  151. struct litlist *lit;
  152. {
  153.     if (lit) {
  154.     if(lit->nextlit)
  155.     printalit(lit->nextlit);
  156.     printlit(lit->litele);
  157.     }
  158. }
  159.  
  160. printlit(lit)
  161. struct litstruct *lit;
  162. {
  163.     if (lit)
  164.     switch(lit->littype) {
  165.      case numlit: fprintf(ofd,"%d ", lit->ll.litint); break;
  166.      case fnumlit: fprintf(ofd,"%s ", lit->ll.litstr); break;
  167.      case charlit: fprintf(ofd,"$%c ", lit->ll.litchar); break;
  168.      case strlit: fprintf(ofd,"\'%s\' ", lit->ll.litstr); break;
  169.      case symlit: fprintf(ofd,"#%s ", lit->ll.litsym); break;
  170.      case arlit: fprintf(ofd,"#( ");
  171.         printalit(lit->ll.litarry);
  172.         fprintf(ofd,") ");
  173.         break;
  174.      default: yerr("unknown literal type %d", lit->littype);
  175.      }
  176. }
  177.  
  178. genmeth(m)
  179. struct methodstruct *m;
  180. {     int i;
  181.  
  182.     fprintf(ofd,"\t#( #[");
  183.     codetop = littop = 0;
  184.     genstate(m->states, 1);
  185.     genhighlow(SPECIAL, SELFRETURN);
  186.     for (i = 0; i < codetop; i++){
  187.         fprintf(ofd," %d", uctoi(code[i]));
  188.         if (i % 15 == 14) fprintf(ofd," \\\n");
  189.     }
  190.     fprintf(ofd,"] \\\n");
  191.     fprintf(ofd,"\t#( ");
  192.     for (i = 0; i < littop; i++)
  193.         printlit(literals[i]);
  194.     fprintf(ofd," ) ) >\n\n");
  195. }
  196.  
  197. genstate(s, doret)
  198. struct statestruct *s;
  199. int doret;
  200. {
  201.     if (s->nextstate)
  202.         genstate(s->nextstate, doret);
  203.     switch(s->statetype) {
  204.     default:
  205.         yerr("unknown case in genstate %d", s->statetype);
  206.     case blkupar:
  207.         gensexpr(s->nn.stateexpr);
  208.         if (inblock)
  209.             genhighlow(SPECIAL, BLOCKRETURN);
  210.         else
  211.             genhighlow(SPECIAL, RETURN);
  212.         popstk(1);
  213.         break;
  214.     case upar:
  215.         gensexpr(s->nn.stateexpr);
  216.         if (doret)
  217.             genhighlow(SPECIAL, RETURN);
  218.         popstk(1);
  219.         break;
  220.     case iasgn:
  221.         gensexpr(s->nn.stateexpr);
  222.         genhighlow(POPINSTANCE, s->mm.varpos);
  223.         popstk(1);
  224.         break;
  225.     case casgn:
  226.         gensexpr(s->nn.stateexpr);
  227.         genhighlow(POPTEMP, s->mm.varpos);
  228.         popstk(1);
  229.         break;
  230.     case expr:
  231.         genexpr(s->nn.cmd);
  232.         genhighlow(SPECIAL, POPSTACK);
  233.         popstk(1);
  234.         break;
  235.     }
  236. }
  237.  
  238. gensexpr(s)
  239. struct statestruct *s;
  240. {
  241.     switch(s->statetype) {
  242.     default:
  243.         yerr("unknown state in gensexpr %d", s->statetype);
  244.     case iasgn:
  245.         gensexpr(s->nn.stateexpr);
  246.         genhighlow(SPECIAL, DUPSTACK);
  247.         bumpstk();
  248.         genhighlow(POPINSTANCE, s->mm.varpos);
  249.         popstk(1);
  250.         break;
  251.     case casgn:
  252.         gensexpr(s->nn.stateexpr);
  253.         genhighlow(SPECIAL, DUPSTACK);
  254.         bumpstk();
  255.         genhighlow(POPTEMP, s->mm.varpos);
  256.         popstk(1);
  257.         break;
  258.     case expr:
  259.         genexpr(s->nn.cmd);
  260.         break;
  261.     }
  262. }
  263.  
  264. int supertest(rec)
  265. struct exprstruct *rec;
  266. {    struct objstruct *o;
  267.  
  268.     if (rec->cmdtype != reccmd)
  269.         return(0);
  270.     o = rec->cc.recobj;
  271.     if (o->objtype != pseuobj)
  272.         return(0);
  273.     if (o->ee.pseuinfo == supervar)
  274.         return(1);
  275.     return(0);
  276. }
  277.  
  278. int isblock(e)
  279. struct exprstruct *e;
  280. {    struct objstruct *o;
  281.  
  282.     if (e->cmdtype != reccmd)
  283.         return(0);
  284.     o = e->cc.recobj;
  285.     if (o->objtype != blockobj)
  286.         return(0);
  287.     return(1);
  288. }
  289.  
  290. genbarg(e)
  291. struct exprstruct *e;
  292. {
  293.     if (isblock(e)) {
  294.         genstate(((e->cc.recobj)->ee.blockinfo)->bstates, 0);
  295.         }
  296.     else {
  297.         genexpr(e);
  298.         genhighlow(UNSEND, VALUECMD);
  299.         }
  300. }
  301.  
  302. fixjump(loc)
  303. int loc;
  304. {    int size;
  305.     
  306.     size = (codetop - loc) - 1;
  307.     if (size > 255)
  308.         yerr("block too big %d", size);
  309.     code[loc] = itouc(size);
  310. }
  311.  
  312. int gencond(message, e)
  313. char *message;
  314. struct exprstruct *e;
  315. {    struct keylist *k;
  316.     int i, j;
  317.  
  318.      k = e->cc.keys;
  319.     i = 0;
  320.     if ((i = streq(message, "ifTrue:")) || streq(message, "ifFalse:")) {
  321.         genhighlow(SPECIAL, i ? SKIPFALSEPUSH : SKIPTRUEPUSH);
  322.         i = codetop;
  323.         gencode(0);
  324.         genbarg(k->arg);
  325.         fixjump(i);
  326.         return(1);
  327.         }
  328.     if ((i = streq(message, "ifTrue:ifFalse:")) || 
  329.             streq(message, "ifFalse:ifTrue:")) {
  330.         genhighlow(SPECIAL, i ? SKIPFALSEPUSH : SKIPTRUEPUSH);
  331.         i = codetop;
  332.         gencode(0);
  333.         genbarg((k->nextkey)->arg);
  334.         genhighlow(SPECIAL, SKIPFORWARD);
  335.         j = codetop;
  336.         gencode(0);
  337.         fixjump(i);
  338.         genhighlow(SPECIAL, POPSTACK);
  339.         popstk(1);
  340.         genbarg(k->arg);
  341.         fixjump(j);
  342.         return(1);
  343.         }
  344.     if ((i = streq(message, "and:")) || streq(message, "or:")) {
  345.         genhighlow(SPECIAL, i ? SKIPF : SKIPT);
  346.         i = codetop;
  347.         gencode(0);
  348.         genbarg(k->arg);
  349.         fixjump(i);
  350.         return(1);
  351.         }
  352.     if ((j = streq(message, "whileTrue:")) ||
  353.             streq(message, "whileFalse:")) {
  354.         i = codetop;
  355.         genbarg(e->receiver);
  356.         genhighlow(SPECIAL, j ? SKIPFALSEPUSH : SKIPTRUEPUSH);
  357.         j = codetop;
  358.         gencode(0);
  359.         genbarg(k->arg);
  360.         genhighlow(SPECIAL, POPSTACK);
  361.         popstk(1);
  362.         genhighlow(SPECIAL, SKIPBACK);
  363.         /* add one because bytecount pointer already advanced */
  364.         gencode((codetop - i) + 1);
  365.         fixjump(j);
  366.         return(1);
  367.         }
  368.     return(0);
  369. }
  370.  
  371. genexpr(e)
  372. struct exprstruct *e;
  373. {    char *message = e->cmdname;
  374.     char **p;
  375.     int    i, numargs, s;
  376.     YYSTYPE ex;
  377.     struct litstruct *mklit();
  378.  
  379.     if (e->cmdtype != reccmd)
  380.         s = supertest(e->receiver);
  381.     switch(e->cmdtype) {
  382.     default:
  383.         yerr("unknown state in genexpr %d", e->cmdtype);
  384.     case reccmd:
  385.         genobj(e->cc.recobj);
  386.         return;
  387.     case semiend:
  388.         genexpr(e->receiver);
  389.         genhighlow(SPECIAL, POPSTACK);
  390.         popstk(1);
  391.         return;
  392.     c